home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Programmer Power Tools
/
Programmer Power Tools.iso
/
bss
/
pup.arc
/
SUPPORT.C
< prev
next >
Wrap
C/C++ Source or Header
|
1987-11-13
|
8KB
|
338 lines
#include <puppy.h>
#include <ascii.h>
#include <pupmem.h>
/*
Various low level and extremely important support routines.
append(fname) Open or create file fname for appending.
logoff(code,disc)
Terminate this call; disconnect from the modem if
disc is true; sets code as the DOS ERRORLEVEL for this
connect. This writes out the caller record as necessary,
etc.
makefname(buf,name)
Creates a full pathname from the current (Msg, File,
Upload, pup.bbs) area. NOTE: If 'ovpath' is not blank,
it is used instead of the one from the area.
rline(f,line,len)
Read a line of text; a line is defined as characters
delimited by a CR. See the code for special cases. Returns
0 if end of file.
char *str_node(&node)
Generates a static string expression of the node, and
returns a pointer to it. Through a kludge it can be
called up to 4 times without overwriting a previous
invokation.
int num_args(string) Returns the number of args in the string, seperated
by delims (see delim(), below). Leading delimiters
are ignored.
char *next_arg(string) Returns a pointer to the next arg, delimited
by a delim, skipping over the current arg. Use via
ptr= nextarg(ptr) to skip to each argument. All
switches at the end of the current arg are skipped.
char *skip_delim(string) Skips leading delims in a string. returns a pointer.
cpyarg(to,from) Copies a string, up to the next delim or switch.
Leading and trailing delimiters are stripped (from
the output string) and a null terminator is added.
after cpyarg() FROM: foo/b foobar fipple
TO: foo
char *strip_path(out,in) Copies the disk specifier or pathname to the output
array, and returns a pointer to the name in the input
string. Drive specs are considered a path, and are
treated as such by DOS. Stripping "a:foo" and
"bin/foo/framis.asm" result in:
IN: "A:"
IN: "bin\foo"
OUT: "A:"
OUT: "bin\"
stolower(s) Convert a string to all lower case
stoupper(s) Convert a string to all upper case
atoi(s) Convert a string of digits into a numeric value; stops
when the first non-digit character is found.
*/
/* Open a file for appending, creating it if necessary. Return the
open handle, or -1 if error. */
append(s)
char *s;
{
int h;
char c;
h= open(s,2); /* open or create the */
if (h == -1) h= creat(s,2); /* file, if opened OK */
else lseek(h,0L,2); /* seek to the end */
return(h); /* handle or error */
}
/* Log a caller off the system; disconnect and force a termination. */
logoff(code,disc)
int code,disc;
{
int f;
char buff[SS];
long p;
limit= 0; /* disable time limits */
doscode= code; /* set result code, */
if (!test && disc) discon(); /* do disconnect, */
frc_abort(); /* force rturn to main */
}
/* Copy the path prefix, append one filename from the input string. */
makefname(d,s)
char *d,*s;
{
strcpy(d,pup.filepref); /* the path prefix, */
d= next_arg(d); /* point to its end, */
cpyarg(d,s); /* add one filename */
}
/* Display a text file. */
dspfile(filename)
char *filename;
{
int f;
f= open(filename,0);
if (f == -1) return(0);
dumptext(f);
close(f);
return(1);
}
/* Output the contents of a text file to the console. The handle of
an open file is passed. Output ceases when EOF or a Control-Z is found. */
dumptext(file)
int file;
{
char lastc,c,buff[512]; /* local buffering */
unsigned index,count;
if (file == -1) return; /* be serious */
index= count= 0; /* buffer is empty */
while (1) {
if (index >= count) { /* read some if */
index= 0; /* the local buffer */
count= read(file,buff,sizeof(buff)); /* is empty */
}
if (! count) break; /* stop if empty file */
if (abort) break; /* stop if aborted */
c= buff[index++]; /* get a character, */
if (c == LF) continue; /* ignore LFs */
if (c == CR + 128) { /* special case soft CRs */
if (lastc == ' ') continue;
c= ' ';
}
lastc= c; /* remember it, */
if (c == CR) mputs("\r\n"); /* CR becomes CR/LF */
else fmconout(c); /* else output text */
if (c == SUB) break; /* ^Z is end of file */
}
mputs("\r\n");
}
/* Write the system file out to disk. */
putsys() {
int f;
f= open("puppy.sys",2);
if (f == -1) {
printf("Can't open PUPPY.SYS!\r\n");
return;
}
write(f,&pup,sizeof(struct _pup));
close(f);
}
/* Read a line of text from the file, null terminate it. Function returns
zero if EOF. Deletes all CRs and Control-Zs from the stream. Lines are
terminated by LFs. */
rline(file,buf,len)
int file;
char *buf;
int len;
{
int i;
char notempty,c;
i= 0; notempty= 0;
--len; /* compensate for added NUL */
while (i < len) {
if (! read(file,&c,1)) break; /* stop if empty */
if (c == 0x1a) continue; /* totally ignore ^Z, */
notempty= 1; /* not empty */
if (c == '\r') continue; /* skip CR, */
if (c == '\r' + 128) continue; /* skip soft CR, */
if (c == '\n') break; /* stop if LF */
buf[i++]= c;
}
buf[i]= '\0';
return(notempty);
}
/* Return the number of args left in the string. */
num_args(s)
char *s;
{
int count;
count= 0;
s= skip_delim(s); /* skip leading blanks, */
while (*s) {
++count; /* count one, */
s= next_arg(s); /* find next, */
}
return(count);
}
/* Return a pointer to the next argument in the string. */
char *next_arg(s)
char *s;
{
while ((!delim(*s)) && *s) /* skip this one, */
++s; /* up to delim, */
s= skip_delim(s); /* then skip delims, */
return(s);
}
/* Skip over the leading delimiters in a string. */
char *skip_delim(s)
char *s;
{
while (delim(*s) && *s) {
++s;
}
return(s);
}
/* Copy the string to the destination array, stopping if we find one
of our delimiters. */
cpyatm(to,from)
char *to;
char *from;
{
while ( (!delim(*from)) && *from)
*to++= *from++;
*to= '\0';
}
/* Copy the string to the destination array, stopping if we find one
of our delimiters. */
cpyarg(to,from)
char *to;
char *from;
{
while (*from) {
if (delim(*from)) break;
*to++= *from++;
}
*to= '\0';
}
/* Strip the pathname or disk specifier from a filename, return it in a
seperate array. We do this by initially copying the entire name in, then
searching for the colon or slash. Right after the last one we find,
stuff a null, removing the name part.
Also return a pointer to the name part in the input name. */
char *strip_path(out,in)
char *out;
char *in;
{
char *name;
char *endpath;
strcpy(out,in); /* duplicate, for working, */
name= in; /* point to name, */
endpath= out; /* and end of path part, */
while (*in) { /* look for slashes or colons, */
if (*in == ':') { /* if a colon, */
endpath= ++out; /* point to name, */
name= ++in;
} else if ((*in == '/') || (*in == '\\')) {
endpath= ++out; /* move the pointer up, */
name= ++in;
} else {
++in;
++out;
}
}
*endpath= '\0'; /* delete the name part, */
return(name); /* return ptr to name part. */
}
/* Convert a string to lower case. */
stolower(s)
char *s;
{
while (*s) {
*s= tolower(*s);
++s;
}
}
/* Convert a string to upper case. */
stoupper(s)
char *s;
{
while (*s) {
*s= toupper(*s);
++s;
}
}
/* atoi() function missing from Lattice C. From Kernighan and Richie. */
atoi(s)
char *s;
{
int n;
n= 0;
while ((*s >= '0') && (*s <= '9')) {
n *= 10;
n += *s - '0';
++s;
}
return(n);
}